…rcion gaps

§20.2.1.1.1 CreateDynamicFunction — three gaps addressed:

1. GeneratorFunction/AsyncFunction: coerce params left-to-right (step 5a)
   and use interp.to_js_string() (ES ToString) for non-string arguments
   instead of MoonBit .to_string().

2. Function: add .prototype.constructor wiring to dynamically created
   functions so that `new (new Function(...))` correctly sets up the
   prototype chain per §20.2.1.1.1 step 27a.

3. AsyncFunction [[Prototype]]: set to the Function constructor per
   §27.7.2, so Object.getPrototypeOf(AsyncFunction) === Function.

4. GeneratorFunction params: add raw-source-text check for `yield` as
   a keyword in param strings (§20.2.1.1.1 step 17a). The parser does
   not enter generator context for params, so yield is parsed as an
   identifier; the keyword check is applied before parse.

All 42 GeneratorFunction and 34 AsyncFunction test262 tests now pass.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

… params

Four targeted fixes from review feedback on PR #476:

1. parse_object_pattern: use expect_ident_name() for property keys so that
   `yield` is accepted as a LiteralPropertyName (ES §12.2.6) even in generator
   context. Fixes GF("{yield: x}", "return x") incorrectly throwing SyntaxError.

2. parse_generator_decl: wrap parse_params_ext() and parse_block_body() calls in
   inline catch blocks so push_generator_context / push_async_context are always
   popped on error, eliminating the parser context-stack leak.

3. pattern_contains_yield: new helper that recursively walks ArrayPat, ObjectPat,
   DefaultPat, and PropPat (computed_key + default_val) so that yield expressions
   nested inside destructuring defaults (e.g. {x = yield} or {[yield]: x}) are
   correctly caught. Property name strings are intentionally excluded.

4. builtins_function.mbt: extract make_function_prototype / wire_constructor_to_prototype
   helpers to deduplicate the identical prototype-object creation and
   constructor back-reference wiring across the FuncDecl, FuncDeclExt, and
   fallback return paths.

GeneratorFunction: 42/42 test262, 2249/2249 unit tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

…g guard, class yield traversal

Three follow-up fixes from second review round on PR #476:

1. parse_func_expr + object method shorthand: push push_generator_context(false)
   and push_async_context before parse_params() (not just before parse_block_body())
   so that nested non-generator params are isolated from an outer generator's
   context. Valid code such as GF("a = function(yield){}", "") or
   GF("a = {m(yield){}}", "") no longer throws. Context cleanup added for all
   error paths (parse_params_ext, parse_block_body) via inline catch.

2. parse_object_pattern: split the fall-through arm on peek_kind_at(1) == Colon
   so that property-key positions ({yield: x}) use expect_ident_name() while
   shorthand BindingIdentifier positions ({yield}) revert to expect_ident() and
   correctly reject reserved words. Fixes regression from the previous commit
   where {if}/{yield} shorthand was silently accepted.

3. expr_contains_yield: ClassExpr is NOT a function boundary for
   Contains(YieldExpression): the heritage expression (extends clause) and
   computed member-key expressions (class { [yield](){} }) are evaluated in the
   enclosing scope (ES §15.7.1). Only the method bodies are a new boundary.
   Split ClassExpr off the false arm and recurse into superclass + computed keys.

GeneratorFunction: 42/42 test262, 2249/2249 unit tests.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

…c_func_body

parse_async_func_body pushed push_generator_context / push_async_context only
after parse_params(), so a nested async function expression inside an outer
generator's default parameter (e.g. GF("a = async function(yield) {}", ""))
parsed its parameter list under the outer generator context, making `yield`
a reserved keyword and incorrectly throwing SyntaxError.

Move both push calls to before parse_params(), mirroring the fix already
applied to parse_func_expr and object-method shorthand in the previous commit.
Error-path cleanup (pop on all raise sites) added for parse_params_ext and
parse_block_body branches.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Two gaps in expr_contains_yield / params_contain_yield:

1. ArrowFuncExt / AsyncArrowFuncExt were treated as full function boundaries and
   returned false for the whole node. Arrow parameter default values are evaluated
   in the enclosing scope (not the arrow's body scope), so they are covered by the
   outer FormalParameters Contains(YieldExpression) check. Split them out of the
   false group and delegate to params_contain_yield, which already walks
   default_val and nested patterns.
   e.g. GF("x = ((a = yield) => {})", "") now throws SyntaxError.

2. DestructureAssign only scanned the RHS expression and skipped the LHS pattern.
   Computed keys ({[yield]: a}) and property defaults ({a = yield}) in the pattern
   are also in the enclosing scope. Extend the arm to call pattern_contains_yield
   on the pattern as well.
   e.g. GF("x = ({[yield]: a} = {})", "") now throws SyntaxError.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Three source-level early errors that were only enforced by the dynamic
GeneratorFunction/AsyncFunction constructors, not by the parser for
regular source code:

1. Generator declaration formal parameters containing YieldExpression
   (function* g(a = yield 1) {}): add params_contain_yield() check after
   parse_params_ext() in parse_generator_decl. The generator context was
   already pushed before params so yield 1 parses as YieldExpr; only the
   early-error raise was missing.

2. Async function expression formal parameters containing AwaitExpression
   (async function(a = await 1) {}): add params_contain_await() check
   after parse_params_ext() in parse_async_func_body. Also adds
   params_contain_yield() for the async generator expression case.

3. Async object method formal parameters containing AwaitExpression
   ({ async m(a = await 1) {} }): add params_contain_await() check after
   parse_params_ext() in the object-method-shorthand ext-params path.

All three checks live in the new parser/early_errors.mbt file which
provides expr_has_yield, pat_has_yield, params_contain_yield and their
_await counterparts. These mirror interpreter/runtime/generator.mbt
so the parser can enforce the ES §15.5.1 / §15.8.1 static semantics
without importing from the interpreter layer.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>